import 'dart:convert';
import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
import 'package:get/get.dart';
import '../../../common/services/index.dart';
import '../../../common/values/constants.dart';

class SharedPreferencesController extends GetxController {
  // 1. 静态常量（类级别）
  static const String tag = 'SharedPreferencesController';
  static const int maxDisplayItems = 100;
  
  // 2. 实例常量
  final String pageTitle = '本地存储管理';
  final Duration animationDuration = const Duration(milliseconds: 300);
  
  // 3. 响应式变量（Rx系列）
  // 基础类型 - 使用.obs写法（推荐95%场景）
  var isLoading = false.obs;                     // RxBool - 数据加载状态
  var isInitialized = false.obs;                 // RxBool - 初始化状态
  var hasError = false.obs;                      // RxBool - 错误状态
  var totalStorageCount = 0.obs;                 // RxInt - 存储项总数
  
  // 集合类型 - 使用.obs写法
  var storageItems = <StorageItem>[].obs;        // RxList<StorageItem> - 存储项列表
  var appSettings = <String, dynamic>{}.obs;     // RxMap<String, dynamic> - 应用设置
  var searchResults = <StorageItem>[].obs;       // RxList<StorageItem> - 搜索结果
  
  // 可空类型 - 特殊场景使用
  var selectedItemKey = RxnString();             // 可空字符串，未选择时为null
  var lastRefreshTime = RxnString();             // 上次刷新时间
  
  // 4. 普通变量（非响应式）
  bool _isDataLoaded = false;
  String _errorMessage = '';
  String _searchKeyword = '';
  
  // 公共访问器
  String get errorMessage => _errorMessage;
  String get searchKeyword => _searchKeyword;
  
  // 5. 控制器和服务依赖
  final TextEditingController searchController = TextEditingController();
  late final StorageService _storageService;
  late final AppConfigService _appConfigService;
  
  // 6. 构造函数
  SharedPreferencesController() {
    debugPrint('$tag: Constructor - 控制器已创建');
    _storageService = Get.find<StorageService>();
    _appConfigService = Get.find<AppConfigService>();
  }

  // 7. 私有初始化方法
  void _initData() async {
    debugPrint('$tag: 开始初始化存储数据');
    
    if (_isDataLoaded) {
      debugPrint('$tag: 数据已加载，跳过初始化');
      return;
    }
    
    await loadStorageData();
    _isDataLoaded = true;
    isInitialized.value = true;
    _errorMessage = ''; // 清空错误信息
    
    debugPrint('$tag: 存储数据初始化完成');
    update(["shared_preferences"]);
  }

  // 8. 业务方法
  
  /// 加载所有存储数据
  Future<void> loadStorageData() async {
    debugPrint('$tag: 开始加载存储数据');
    isLoading.value = true;
    hasError.value = false;
    
    try {
      // 清空现有数据
      storageItems.clear();
      appSettings.clear();
      
      // 加载应用级设置
      await _loadAppSettings();
      
      // 加载所有存储项
      await _loadAllStorageItems();
      
      // 更新统计信息
      totalStorageCount.value = storageItems.length;
      lastRefreshTime.value = DateTime.now().toString().substring(0, 19);
      
      debugPrint('$tag: 存储数据加载完成，共${storageItems.length}项');
      
    } catch (e) {
      _errorMessage = '加载存储数据失败: ${e.toString()}';
      debugPrint('$tag: $_errorMessage');
      hasError.value = true;
    } finally {
      isLoading.value = false;
      update(["shared_preferences"]);
    }
  }
  
  /// 加载应用级设置
  Future<void> _loadAppSettings() async {
    debugPrint('$tag: 加载应用级设置');
    
    appSettings.assignAll({
      '深色模式': _appConfigService.isDarkMode,
      '语言设置': _appConfigService.language,
      '首次运行': _appConfigService.isFirstRun,
      '应用版本': _appConfigService.getSavedAppVersion().isEmpty ? '未设置' : _appConfigService.getSavedAppVersion(),
      '服务状态': _appConfigService.isInitialized ? '已初始化' : '未初始化',
    });
  }
  
  /// 加载所有存储项
  Future<void> _loadAllStorageItems() async {
    debugPrint('$tag: 加载所有存储项');
    
    try {
      final allKeys = _storageService.getAllKeys();
      debugPrint('$tag: 发现${allKeys.length}个存储键');
      
      final List<StorageItem> items = [];
      
      for (final key in allKeys) {
        final item = _createStorageItemFromKey(key);
        if (item != null) {
          items.add(item);
        }
      }
      
      // 按键名排序
      items.sort((a, b) => a.key.compareTo(b.key));
      storageItems.assignAll(items);
      
    } catch (e) {
      debugPrint('$tag: 加载存储项失败: $e');
      rethrow;
    }
  }
  
  /// 从键创建存储项对象
  StorageItem? _createStorageItemFromKey(String key) {
    try {
      // 使用StorageService的类型检测方法，避免类型转换错误
      final valueType = _storageService.getValueType(key);
      
      switch (valueType) {
        case 'Bool':
          final boolValue = _storageService.getBool(key);
          if (boolValue != null) {
            return StorageItem(
              key: key,
              value: boolValue.toString(),
              type: 'Bool',
              isAppSetting: _isAppSettingKey(key),
            );
          }
          break;
          
        case 'Int':
          final intValue = _storageService.getInt(key);
          if (intValue != null) {
            return StorageItem(
              key: key,
              value: intValue.toString(),
              type: 'Int',
              isAppSetting: _isAppSettingKey(key),
            );
          }
          break;
          
        case 'Double':
          final stringValue = _storageService.getString(key);
          if (stringValue != null) {
            return StorageItem(
              key: key,
              value: stringValue,
              type: 'Double',
              isAppSetting: _isAppSettingKey(key),
            );
          }
          break;
          
        case 'Object':
          final objectValue = _storageService.getObject(key);
          if (objectValue != null) {
            return StorageItem(
              key: key,
              value: objectValue.toString(),
              type: 'Object',
              isAppSetting: _isAppSettingKey(key),
            );
          }
          break;
          
        case 'String':
          final stringValue = _storageService.getString(key);
          if (stringValue != null) {
            return StorageItem(
              key: key,
              value: stringValue,
              type: 'String',
              isAppSetting: _isAppSettingKey(key),
            );
          }
          break;
          
        case 'StringList':
          final stringValue = _storageService.getString(key);
          if (stringValue != null) {
            return StorageItem(
              key: key,
              value: stringValue,
              type: 'StringList',
              isAppSetting: _isAppSettingKey(key),
            );
          }
          break;
          
        default:
          debugPrint('$tag: 未知类型 [$key]: $valueType');
          return null;
      }
      
      return null;
    } catch (e) {
      debugPrint('$tag: 处理键[$key]失败: $e');
      return null;
    }
  }
  
  /// 判断是否为应用设置键
  bool _isAppSettingKey(String key) {
    const appKeys = [
      Constants.storageKeyDarkMode,
      Constants.storageKeyLanguage,
      Constants.storageKeyFirstRun,
      Constants.storageKeyAppVersion,
    ];
    return appKeys.contains(key);
  }
  
  /// 搜索存储项
  void searchStorageItems(String keyword) {
    debugPrint('$tag: 搜索存储项: $keyword');
    _searchKeyword = keyword;
    
    if (keyword.isEmpty) {
      searchResults.clear();
    } else {
      final results = storageItems.where((item) =>
        item.key.toLowerCase().contains(keyword.toLowerCase()) ||
        item.value.toLowerCase().contains(keyword.toLowerCase())
      ).toList();
      
      searchResults.assignAll(results);
      debugPrint('$tag: 搜索到${results.length}个结果');
    }
    
    update(["shared_preferences"]);
  }
  
  /// 删除指定键的存储项
  Future<void> deleteStorageItem(String key) async {
    debugPrint('$tag: 删除存储项: $key');
    
    try {
      final success = await _storageService.remove(key);
      if (success) {
        // 从列表中移除
        storageItems.removeWhere((item) => item.key == key);
        searchResults.removeWhere((item) => item.key == key);
        totalStorageCount.value = storageItems.length;
        
        debugPrint('$tag: 存储项[$key]删除成功');
        // Get.snackbar('删除成功', '存储项 $key 已删除');
      } else {
        debugPrint('$tag: 存储项[$key]删除失败');
        // Get.snackbar('删除失败', '无法删除存储项 $key');
      }
    } catch (e) {
      debugPrint('$tag: 删除存储项异常: $e');
      // Get.snackbar('删除失败', '删除存储项时发生错误: ${e.toString()}');
    }
    
    update(["shared_preferences"]);
  }
  
  /// 清空所有存储数据
  Future<void> clearAllStorageData() async {
    debugPrint('$tag: 清空所有存储数据');
    
    try {
      final success = await _storageService.clear();
      if (success) {
        storageItems.clear();
        searchResults.clear();
        appSettings.clear();
        totalStorageCount.value = 0;
        
        debugPrint('$tag: 所有存储数据已清空');
        // Get.snackbar('清空成功', '所有存储数据已清空');
        
        // 重新加载应用设置（因为clear后会重置为默认值）
        await _loadAppSettings();
      } else {
        debugPrint('$tag: 清空存储数据失败');
        // Get.snackbar('清空失败', '无法清空存储数据');
      }
    } catch (e) {
      debugPrint('$tag: 清空存储数据异常: $e');
      // Get.snackbar('清空失败', '清空存储数据时发生错误: ${e.toString()}');
    }
    
    update(["shared_preferences"]);
  }
  
  /// 刷新存储数据
  Future<void> refreshStorageData() async {
    debugPrint('$tag: 刷新存储数据');
    
    // 重置搜索
    searchController.clear();
    _searchKeyword = '';
    searchResults.clear();
    selectedItemKey.value = null;
    
    // 重新加载数据
    await loadStorageData();
  }
  
  /// 选择存储项
  void selectStorageItem(String key) {
    debugPrint('$tag: 选择存储项: $key');
    selectedItemKey.value = selectedItemKey.value == key ? null : key;
    update(["shared_preferences"]);
  }
  
  /// 显示存储项详情
  void showStorageItemDetail(StorageItem item) {
    debugPrint('$tag: 显示存储项详情: ${item.key}');
    // 这个方法将在view中调用，显示详情弹窗
  }
  
  /// 格式化JSON字符串
  String formatJsonString(String jsonString) {
    try {
      final dynamic jsonObject = jsonDecode(jsonString);
      const encoder = JsonEncoder.withIndent('  '); // 使用2个空格缩进
      return encoder.convert(jsonObject);
    } catch (e) {
      debugPrint('$tag: JSON格式化失败: $e');
      return jsonString; // 如果格式化失败，返回原字符串
    }
  }

  /// 检查字符串是否为有效的JSON
  bool isValidJson(String str) {
    try {
      jsonDecode(str);
      return true;
    } catch (e) {
      return false;
    }
  }

  /// 获取存储项的完整信息
  Map<String, dynamic> getStorageItemDetail(String key) {
    try {
      final valueType = _storageService.getValueType(key);
      final keyExists = _storageService.containsKey(key);
      
      dynamic rawValue;
      String displayValue = '';
      String formattedValue = '';
      bool isJsonFormatted = false;
      
      if (keyExists) {
        switch (valueType) {
          case 'Bool':
            rawValue = _storageService.getBool(key);
            displayValue = rawValue?.toString() ?? 'null';
            formattedValue = displayValue;
            break;
          case 'Int':
            rawValue = _storageService.getInt(key);
            displayValue = rawValue?.toString() ?? 'null';
            formattedValue = displayValue;
            break;
          case 'String':
            rawValue = _storageService.getString(key);
            displayValue = rawValue ?? 'null';
            // 检查是否为JSON字符串
            if (rawValue != null && isValidJson(rawValue)) {
              formattedValue = formatJsonString(rawValue);
              isJsonFormatted = true;
            } else {
              formattedValue = displayValue;
            }
            break;
          case 'Object':
            rawValue = _storageService.getObject(key);
            displayValue = rawValue?.toString() ?? 'null';
            // 对于Object类型，尝试格式化显示
            if (rawValue != null) {
              try {
                const encoder = JsonEncoder.withIndent('  ');
                formattedValue = encoder.convert(rawValue);
                isJsonFormatted = true;
              } catch (e) {
                formattedValue = displayValue;
              }
            } else {
              formattedValue = displayValue;
            }
            break;
          default:
            rawValue = _storageService.getString(key);
            displayValue = rawValue ?? 'null';
            formattedValue = displayValue;
        }
      } else {
        rawValue = null;
        displayValue = 'Key not found';
        formattedValue = displayValue;
      }
      
      return {
        'key': key,
        'type': valueType,
        'rawValue': rawValue,
        'displayValue': displayValue,
        'formattedValue': formattedValue,
        'isJsonFormatted': isJsonFormatted,
        'isAppSetting': _isAppSettingKey(key),
        'keyExists': keyExists,
        'valueLength': displayValue.length,
        'lastModified': DateTime.now().toString(), // SharedPreferences 不支持获取修改时间
      };
    } catch (e) {
      debugPrint('$tag: 获取存储项详情失败 [$key]: $e');
      return {
        'key': key,
        'type': 'Unknown',
        'rawValue': null,
        'displayValue': 'Error loading value',
        'formattedValue': 'Error loading value',
        'isJsonFormatted': false,
        'isAppSetting': false,
        'keyExists': false,
        'valueLength': 0,
        'lastModified': 'Unknown',
      };
    }
  }
  
  /// 获取存储项统计信息
  Map<String, int> getStorageStats() {
    final stats = <String, int>{};
    for (final item in storageItems) {
      stats[item.type] = (stats[item.type] ?? 0) + 1;
    }
    return stats;
  }

  // 9. 生命周期方法
  @override
  void onInit() {
    super.onInit();
    debugPrint('$tag: onInit - 控制器初始化');
  }

  @override
  void onReady() {
    super.onReady();
    debugPrint('$tag: onReady - 页面准备就绪');
    _initData();
  }
  
  @override
  void onClose() {
    debugPrint('$tag: onClose - 控制器销毁');
    // 清理资源
    searchController.dispose();
    storageItems.clear();
    searchResults.clear();
    appSettings.clear();
    super.onClose();
  }
}

/// 存储项数据模型
class StorageItem {
  final String key;
  final String value;
  final String type;
  final bool isAppSetting;

  const StorageItem({
    required this.key,
    required this.value,
    required this.type,
    required this.isAppSetting,
  });

  @override
  String toString() {
    return 'StorageItem{key: $key, value: $value, type: $type, isAppSetting: $isAppSetting}';
  }
}
